// /**
//  * @defgroup LLVMCExecutionEngineORC On-Request-Compilation
//  * @ingroup LLVMCExecutionEngine
//  *
//  * @{
//  */
//
// /**
//  * Represents generic linkage flags for a symbol definition.
//  */
// typedef enum {
//   LLVMJITSymbolGenericFlagsNone = 0,
//   LLVMJITSymbolGenericFlagsExported = 1U << 0,
//   LLVMJITSymbolGenericFlagsWeak = 1U << 1,
//   LLVMJITSymbolGenericFlagsCallable = 1U << 2,
//   LLVMJITSymbolGenericFlagsMaterializationSideEffectsOnly = 1U << 3
// } LLVMJITSymbolGenericFlags;
//
// /**
//  * Represents target specific flags for a symbol definition.
//  */
// typedef uint8_t LLVMJITSymbolTargetFlags;
//
// /**
//  * Represents the linkage flags for a symbol definition.
//  */
// typedef struct {
//   uint8_t GenericFlags;
//   uint8_t TargetFlags;
// } LLVMJITSymbolFlags;
//
// /**
//  * Represents an evaluated symbol address and flags.
//  */
// typedef struct {
//   LLVMOrcExecutorAddress Address;
//   LLVMJITSymbolFlags Flags;
// } LLVMJITEvaluatedSymbol;
//
// /**
//  * A reference to an orc::ExecutionSession instance.
//  */
// typedef struct LLVMOrcOpaqueExecutionSession *LLVMOrcExecutionSessionRef;
//
// /**
//  * Error reporter function.
//  */
// typedef void (*LLVMOrcErrorReporterFunction)(void *Ctx, LLVMErrorRef Err);
//
// /**
//  * A reference to an orc::SymbolStringPool.
//  */
// typedef struct LLVMOrcOpaqueSymbolStringPool *LLVMOrcSymbolStringPoolRef;
//
// /**
//  * A reference to an orc::SymbolStringPool table entry.
//  */
// typedef struct LLVMOrcOpaqueSymbolStringPoolEntry
//     *LLVMOrcSymbolStringPoolEntryRef;
//
// /**
//  * Represents a pair of a symbol name and LLVMJITSymbolFlags.
//  */
// typedef struct {
//   LLVMOrcSymbolStringPoolEntryRef Name;
//   LLVMJITSymbolFlags Flags;
// } LLVMOrcCSymbolFlagsMapPair;
//
// /**
//  * Represents a list of (SymbolStringPtr, JITSymbolFlags) pairs that can be used
//  * to construct a SymbolFlagsMap.
//  */
// typedef LLVMOrcCSymbolFlagsMapPair *LLVMOrcCSymbolFlagsMapPairs;
//
// /**
//  * Represents a pair of a symbol name and an evaluated symbol.
//  */
// typedef struct {
//   LLVMOrcSymbolStringPoolEntryRef Name;
//   LLVMJITEvaluatedSymbol Sym;
// } LLVMOrcCSymbolMapPair;
//
// /**
//  * Represents a list of (SymbolStringPtr, JITEvaluatedSymbol) pairs that can be
//  * used to construct a SymbolMap.
//  */
// typedef LLVMOrcCSymbolMapPair *LLVMOrcCSymbolMapPairs;
//
// /**
//  * Represents a SymbolAliasMapEntry
//  */
// typedef struct {
//   LLVMOrcSymbolStringPoolEntryRef Name;
//   LLVMJITSymbolFlags Flags;
// } LLVMOrcCSymbolAliasMapEntry;
//
// /**
//  * Represents a pair of a symbol name and SymbolAliasMapEntry.
//  */
// typedef struct {
//   LLVMOrcSymbolStringPoolEntryRef Name;
//   LLVMOrcCSymbolAliasMapEntry Entry;
// } LLVMOrcCSymbolAliasMapPair;
//
// /**
//  * Represents a list of (SymbolStringPtr, (SymbolStringPtr, JITSymbolFlags))
//  * pairs that can be used to construct a SymbolFlagsMap.
//  */
// typedef LLVMOrcCSymbolAliasMapPair *LLVMOrcCSymbolAliasMapPairs;
//
// /**
//  * A reference to an orc::JITDylib instance.
//  */
// typedef struct LLVMOrcOpaqueJITDylib *LLVMOrcJITDylibRef;
//
// /**
//  * Represents a list of LLVMOrcSymbolStringPoolEntryRef and the associated
//  * length.
//  */
// typedef struct {
//   LLVMOrcSymbolStringPoolEntryRef *Symbols;
//   size_t Length;
// } LLVMOrcCSymbolsList;
//
// /**
//  * Represents a pair of a JITDylib and LLVMOrcCSymbolsList.
//  */
// typedef struct {
//   LLVMOrcJITDylibRef JD;
//   LLVMOrcCSymbolsList Names;
// } LLVMOrcCDependenceMapPair;
//
// /**
//  * Represents a list of (JITDylibRef, (LLVMOrcSymbolStringPoolEntryRef*,
//  * size_t)) pairs that can be used to construct a SymbolDependenceMap.
//  */
// typedef LLVMOrcCDependenceMapPair *LLVMOrcCDependenceMapPairs;
//
// /**
//  * A set of symbols that share dependencies.
//  */
// typedef struct {
//   LLVMOrcCSymbolsList Symbols;
//   LLVMOrcCDependenceMapPairs Dependencies;
//   size_t NumDependencies;
// } LLVMOrcCSymbolDependenceGroup;
//
// /**
//  * Lookup kind. This can be used by definition generators when deciding whether
//  * to produce a definition for a requested symbol.
//  *
//  * This enum should be kept in sync with llvm::orc::LookupKind.
//  */
// typedef enum {
//   LLVMOrcLookupKindStatic,
//   LLVMOrcLookupKindDLSym
// } LLVMOrcLookupKind;
//
// /**
//  * JITDylib lookup flags. This can be used by definition generators when
//  * deciding whether to produce a definition for a requested symbol.
//  *
//  * This enum should be kept in sync with llvm::orc::JITDylibLookupFlags.
//  */
// typedef enum {
//   LLVMOrcJITDylibLookupFlagsMatchExportedSymbolsOnly,
//   LLVMOrcJITDylibLookupFlagsMatchAllSymbols
// } LLVMOrcJITDylibLookupFlags;
//
// /**
//  * An element type for a JITDylib search order.
//  */
// typedef struct {
//   LLVMOrcJITDylibRef JD;
//   LLVMOrcJITDylibLookupFlags JDLookupFlags;
// } LLVMOrcCJITDylibSearchOrderElement;
//
// /**
//  * A JITDylib search order.
//  *
//  * The list is terminated with an element containing a null pointer for the JD
//  * field.
//  */
// typedef LLVMOrcCJITDylibSearchOrderElement *LLVMOrcCJITDylibSearchOrder;
//
// /**
//  * Symbol lookup flags for lookup sets. This should be kept in sync with
//  * llvm::orc::SymbolLookupFlags.
//  */
// typedef enum {
//   LLVMOrcSymbolLookupFlagsRequiredSymbol,
//   LLVMOrcSymbolLookupFlagsWeaklyReferencedSymbol
// } LLVMOrcSymbolLookupFlags;
//
// /**
//  * An element type for a symbol lookup set.
//  */
// typedef struct {
//   LLVMOrcSymbolStringPoolEntryRef Name;
//   LLVMOrcSymbolLookupFlags LookupFlags;
// } LLVMOrcCLookupSetElement;
//
// /**
//  * A set of symbols to look up / generate.
//  *
//  * The list is terminated with an element containing a null pointer for the
//  * Name field.
//  *
//  * If a client creates an instance of this type then they are responsible for
//  * freeing it, and for ensuring that all strings have been retained over the
//  * course of its life. Clients receiving a copy from a callback are not
//  * responsible for managing lifetime or retain counts.
//  */
// typedef LLVMOrcCLookupSetElement *LLVMOrcCLookupSet;
//
// /**
//  * A reference to a uniquely owned orc::MaterializationUnit instance.
//  */
// typedef struct LLVMOrcOpaqueMaterializationUnit *LLVMOrcMaterializationUnitRef;
//
// /**
//  * A reference to a uniquely owned orc::MaterializationResponsibility instance.
//  *
//  * Ownership must be passed to a lower-level layer in a JIT stack.
//  */
// typedef struct LLVMOrcOpaqueMaterializationResponsibility
//     *LLVMOrcMaterializationResponsibilityRef;
//
// /**
//  * A MaterializationUnit materialize callback.
//  *
//  * Ownership of the Ctx and MR arguments passes to the callback which must
//  * adhere to the LLVMOrcMaterializationResponsibilityRef contract (see comment
//  * for that type).
//  *
//  * If this callback is called then the LLVMOrcMaterializationUnitDestroy
//  * callback will NOT be called.
//  */
// typedef void (*LLVMOrcMaterializationUnitMaterializeFunction)(
//     void *Ctx, LLVMOrcMaterializationResponsibilityRef MR);
//
// /**
//  * A MaterializationUnit discard callback.
//  *
//  * Ownership of JD and Symbol remain with the caller: These arguments should
//  * not be disposed of or released.
//  */
// typedef void (*LLVMOrcMaterializationUnitDiscardFunction)(
//     void *Ctx, LLVMOrcJITDylibRef JD, LLVMOrcSymbolStringPoolEntryRef Symbol);
//
// /**
//  * A MaterializationUnit destruction callback.
//  *
//  * If a custom MaterializationUnit is destroyed before its Materialize
//  * function is called then this function will be called to provide an
//  * opportunity for the underlying program representation to be destroyed.
//  */
// typedef void (*LLVMOrcMaterializationUnitDestroyFunction)(void *Ctx);
//
// /**
//  * A reference to an orc::ResourceTracker instance.
//  */
// typedef struct LLVMOrcOpaqueResourceTracker *LLVMOrcResourceTrackerRef;
//
// /**
//  * A reference to an orc::DefinitionGenerator.
//  */
// typedef struct LLVMOrcOpaqueDefinitionGenerator
//     *LLVMOrcDefinitionGeneratorRef;
//
// /**
//  * An opaque lookup state object. Instances of this type can be captured to
//  * suspend a lookup while a custom generator function attempts to produce a
//  * definition.
//  *
//  * If a client captures a lookup state object then they must eventually call
//  * LLVMOrcLookupStateContinueLookup to restart the lookup. This is required
//  * in order to release memory allocated for the lookup state, even if errors
//  * have occurred while the lookup was suspended (if these errors have made the
//  * lookup impossible to complete then it will issue its own error before
//  * destruction).
//  */
// typedef struct LLVMOrcOpaqueLookupState *LLVMOrcLookupStateRef;
//
// /**
//  * A custom generator function. This can be used to create a custom generator
//  * object using LLVMOrcCreateCustomCAPIDefinitionGenerator. The resulting
//  * object can be attached to a JITDylib, via LLVMOrcJITDylibAddGenerator, to
//  * receive callbacks when lookups fail to match existing definitions.
//  *
//  * GeneratorObj will contain the address of the custom generator object.
//  *
//  * Ctx will contain the context object passed to
//  * LLVMOrcCreateCustomCAPIDefinitionGenerator.
//  *
//  * LookupState will contain a pointer to an LLVMOrcLookupStateRef object. This
//  * can optionally be modified to make the definition generation process
//  * asynchronous: If the LookupStateRef value is copied, and the original
//  * LLVMOrcLookupStateRef set to null, the lookup will be suspended. Once the
//  * asynchronous definition process has been completed clients must call
//  * LLVMOrcLookupStateContinueLookup to continue the lookup (this should be
//  * done unconditionally, even if errors have occurred in the mean time, to
//  * free the lookup state memory and notify the query object of the failures).
//  * If LookupState is captured this function must return LLVMErrorSuccess.
//  *
//  * The Kind argument can be inspected to determine the lookup kind (e.g.
//  * as-if-during-static-link, or as-if-during-dlsym).
//  *
//  * The JD argument specifies which JITDylib the definitions should be generated
//  * into.
//  *
//  * The JDLookupFlags argument can be inspected to determine whether the original
//  * lookup included non-exported symbols.
//  *
//  * Finally, the LookupSet argument contains the set of symbols that could not
//  * be found in JD already (the set of generation candidates).
//  */
// typedef LLVMErrorRef (*LLVMOrcCAPIDefinitionGeneratorTryToGenerateFunction)(
//     LLVMOrcDefinitionGeneratorRef GeneratorObj, void *Ctx,
//     LLVMOrcLookupStateRef *LookupState, LLVMOrcLookupKind Kind,
//     LLVMOrcJITDylibRef JD, LLVMOrcJITDylibLookupFlags JDLookupFlags,
//     LLVMOrcCLookupSet LookupSet, size_t LookupSetSize);
//
// /**
//  * Disposer for a custom generator.
//  *
//  * Will be called by ORC when the JITDylib that the generator is attached to
//  * is destroyed.
//  */
// typedef void (*LLVMOrcDisposeCAPIDefinitionGeneratorFunction)(void *Ctx);
//
// /**
//  * Predicate function for SymbolStringPoolEntries.
//  */
// typedef int (*LLVMOrcSymbolPredicate)(void *Ctx,
//                                       LLVMOrcSymbolStringPoolEntryRef Sym);
//
// /**
//  * A reference to an orc::ThreadSafeContext instance.
//  */
// typedef struct LLVMOrcOpaqueThreadSafeContext *LLVMOrcThreadSafeContextRef;

///|
#external
pub type LLVMOrcThreadSafeContextRef

//
// /**
//  * A reference to an orc::ThreadSafeModule instance.
//  */
// typedef struct LLVMOrcOpaqueThreadSafeModule *LLVMOrcThreadSafeModuleRef;

///|
#external
pub type LLVMOrcThreadSafeModuleRef

// /**
//  * A function for inspecting/mutating IR modules, suitable for use with
//  * LLVMOrcThreadSafeModuleWithModuleDo.
//  */
// typedef LLVMErrorRef (*LLVMOrcGenericIRModuleOperationFunction)(
//     void *Ctx, LLVMModuleRef M);
//
// /**
//  * A reference to an orc::JITTargetMachineBuilder instance.
//  */
// typedef struct LLVMOrcOpaqueJITTargetMachineBuilder
//     *LLVMOrcJITTargetMachineBuilderRef;
//
// /**
//  * A reference to an orc::ObjectLayer instance.
//  */
// typedef struct LLVMOrcOpaqueObjectLayer *LLVMOrcObjectLayerRef;
//
// /**
//  * A reference to an orc::ObjectLinkingLayer instance.
//  */
// typedef struct LLVMOrcOpaqueObjectLinkingLayer *LLVMOrcObjectLinkingLayerRef;
//
// /**
//  * A reference to an orc::IRTransformLayer instance.
//  */
// typedef struct LLVMOrcOpaqueIRTransformLayer *LLVMOrcIRTransformLayerRef;
//
// /**
//  * A function for applying transformations as part of an transform layer.
//  *
//  * Implementations of this type are responsible for managing the lifetime
//  * of the Module pointed to by ModInOut: If the LLVMModuleRef value is
//  * overwritten then the function is responsible for disposing of the incoming
//  * module. If the module is simply accessed/mutated in-place then ownership
//  * returns to the caller and the function does not need to do any lifetime
//  * management.
//  *
//  * Clients can call LLVMOrcLLJITGetIRTransformLayer to obtain the transform
//  * layer of a LLJIT instance, and use LLVMOrcIRTransformLayerSetTransform
//  * to set the function. This can be used to override the default transform
//  * layer.
//  */
// typedef LLVMErrorRef (*LLVMOrcIRTransformLayerTransformFunction)(
//     void *Ctx, LLVMOrcThreadSafeModuleRef *ModInOut,
//     LLVMOrcMaterializationResponsibilityRef MR);
//
// /**
//  * A reference to an orc::ObjectTransformLayer instance.
//  */
// typedef struct LLVMOrcOpaqueObjectTransformLayer
//     *LLVMOrcObjectTransformLayerRef;
//
// /**
//  * A function for applying transformations to an object file buffer.
//  *
//  * Implementations of this type are responsible for managing the lifetime
//  * of the memory buffer pointed to by ObjInOut: If the LLVMMemoryBufferRef
//  * value is overwritten then the function is responsible for disposing of the
//  * incoming buffer. If the buffer is simply accessed/mutated in-place then
//  * ownership returns to the caller and the function does not need to do any
//  * lifetime management.
//  *
//  * The transform is allowed to return an error, in which case the ObjInOut
//  * buffer should be disposed of and set to null.
//  */
// typedef LLVMErrorRef (*LLVMOrcObjectTransformLayerTransformFunction)(
//     void *Ctx, LLVMMemoryBufferRef *ObjInOut);
//
// /**
//  * A reference to an orc::IndirectStubsManager instance.
//  */
// typedef struct LLVMOrcOpaqueIndirectStubsManager
//     *LLVMOrcIndirectStubsManagerRef;
//
// /**
//  * A reference to an orc::LazyCallThroughManager instance.
//  */
// typedef struct LLVMOrcOpaqueLazyCallThroughManager
//     *LLVMOrcLazyCallThroughManagerRef;
//
// /**
//  * A reference to an orc::DumpObjects object.
//  *
//  * Can be used to dump object files to disk with unique names. Useful as an
//  * ObjectTransformLayer transform.
//  */
// typedef struct LLVMOrcOpaqueDumpObjects *LLVMOrcDumpObjectsRef;
//
// /**
//  * Attach a custom error reporter function to the ExecutionSession.
//  *
//  * The error reporter will be called to deliver failure notices that can not be
//  * directly reported to a caller. For example, failure to resolve symbols in
//  * the JIT linker is typically reported via the error reporter (callers
//  * requesting definitions from the JIT will typically be delivered a
//  * FailureToMaterialize error instead).
//  */
// void LLVMOrcExecutionSessionSetErrorReporter(
//     LLVMOrcExecutionSessionRef ES, LLVMOrcErrorReporterFunction ReportError,
//     void *Ctx);
//
// /**
//  * Return a reference to the SymbolStringPool for an ExecutionSession.
//  *
//  * Ownership of the pool remains with the ExecutionSession: The caller is
//  * not required to free the pool.
//  */
// LLVMOrcSymbolStringPoolRef
// LLVMOrcExecutionSessionGetSymbolStringPool(LLVMOrcExecutionSessionRef ES);
//
// /**
//  * Clear all unreferenced symbol string pool entries.
//  *
//  * This can be called at any time to release unused entries in the
//  * ExecutionSession's string pool. Since it locks the pool (preventing
//  * interning of any new strings) it is recommended that it only be called
//  * infrequently, ideally when the caller has reason to believe that some
//  * entries will have become unreferenced, e.g. after removing a module or
//  * closing a JITDylib.
//  */
// void LLVMOrcSymbolStringPoolClearDeadEntries(LLVMOrcSymbolStringPoolRef SSP);
//
// /**
//  * Intern a string in the ExecutionSession's SymbolStringPool and return a
//  * reference to it. This increments the ref-count of the pool entry, and the
//  * returned value should be released once the client is done with it by
//  * calling LLVMOrcReleaseSymbolStringPoolEntry.
//  *
//  * Since strings are uniqued within the SymbolStringPool
//  * LLVMOrcSymbolStringPoolEntryRefs can be compared by value to test string
//  * equality.
//  *
//  * Note that this function does not perform linker-mangling on the string.
//  */
// LLVMOrcSymbolStringPoolEntryRef
// LLVMOrcExecutionSessionIntern(LLVMOrcExecutionSessionRef ES, const char *Name);
//
// /**
//  * Callback type for ExecutionSession lookups.
//  *
//  * If Err is LLVMErrorSuccess then Result will contain a pointer to a
//  * list of ( SymbolStringPtr, JITEvaluatedSymbol ) pairs of length NumPairs.
//  *
//  * If Err is a failure value then Result and Ctx are undefined and should
//  * not be accessed. The Callback is responsible for handling the error
//  * value (e.g. by calling LLVMGetErrorMessage + LLVMDisposeErrorMessage).
//  *
//  * The caller retains ownership of the Result array and will release all
//  * contained symbol names. Clients are responsible for retaining any symbol
//  * names that they wish to hold after the function returns.
//  */
// typedef void (*LLVMOrcExecutionSessionLookupHandleResultFunction)(
//     LLVMErrorRef Err, LLVMOrcCSymbolMapPairs Result, size_t NumPairs,
//     void *Ctx);
//
// /**
//  * Look up symbols in an execution session.
//  *
//  * This is a wrapper around the general ExecutionSession::lookup function.
//  *
//  * The SearchOrder argument contains a list of (JITDylibs, JITDylibSearchFlags)
//  * pairs that describe the search order. The JITDylibs will be searched in the
//  * given order to try to find the symbols in the Symbols argument.
//  *
//  * The Symbols argument should contain a null-terminated array of
//  * (SymbolStringPtr, SymbolLookupFlags) pairs describing the symbols to be
//  * searched for. This function takes ownership of the elements of the Symbols
//  * array. The Name fields of the Symbols elements are taken to have been
//  * retained by the client for this function. The client should *not* release the
//  * Name fields, but are still responsible for destroying the array itself.
//  *
//  * The HandleResult function will be called once all searched for symbols have
//  * been found, or an error occurs. The HandleResult function will be passed an
//  * LLVMErrorRef indicating success or failure, and (on success) a
//  * null-terminated LLVMOrcCSymbolMapPairs array containing the function result,
//  * and the Ctx value passed to the lookup function.
//  *
//  * The client is fully responsible for managing the lifetime of the Ctx object.
//  * A common idiom is to allocate the context prior to the lookup and deallocate
//  * it in the handler.
//  *
//  * THIS API IS EXPERIMENTAL AND LIKELY TO CHANGE IN THE NEAR FUTURE!
//  */
// void LLVMOrcExecutionSessionLookup(
//     LLVMOrcExecutionSessionRef ES, LLVMOrcLookupKind K,
//     LLVMOrcCJITDylibSearchOrder SearchOrder, size_t SearchOrderSize,
//     LLVMOrcCLookupSet Symbols, size_t SymbolsSize,
//     LLVMOrcExecutionSessionLookupHandleResultFunction HandleResult, void *Ctx);
//
// /**
//  * Increments the ref-count for a SymbolStringPool entry.
//  */
// void LLVMOrcRetainSymbolStringPoolEntry(LLVMOrcSymbolStringPoolEntryRef S);
//
// /**
//  * Reduces the ref-count for of a SymbolStringPool entry.
//  */
// void LLVMOrcReleaseSymbolStringPoolEntry(LLVMOrcSymbolStringPoolEntryRef S);
//
// /**
//  * Return the c-string for the given symbol. This string will remain valid until
//  * the entry is freed (once all LLVMOrcSymbolStringPoolEntryRefs have been
//  * released).
//  */
// const char *LLVMOrcSymbolStringPoolEntryStr(LLVMOrcSymbolStringPoolEntryRef S);
//
// /**
//  * Reduces the ref-count of a ResourceTracker.
//  */
// void LLVMOrcReleaseResourceTracker(LLVMOrcResourceTrackerRef RT);
//
// /**
//  * Transfers tracking of all resources associated with resource tracker SrcRT
//  * to resource tracker DstRT.
//  */
// void LLVMOrcResourceTrackerTransferTo(LLVMOrcResourceTrackerRef SrcRT,
//                                       LLVMOrcResourceTrackerRef DstRT);
//
// /**
//  * Remove all resources associated with the given tracker. See
//  * ResourceTracker::remove().
//  */
// LLVMErrorRef LLVMOrcResourceTrackerRemove(LLVMOrcResourceTrackerRef RT);
//
// /**
//  * Dispose of a JITDylib::DefinitionGenerator. This should only be called if
//  * ownership has not been passed to a JITDylib (e.g. because some error
//  * prevented the client from calling LLVMOrcJITDylibAddGenerator).
//  */
// void LLVMOrcDisposeDefinitionGenerator(LLVMOrcDefinitionGeneratorRef DG);
//
// /**
//  * Dispose of a MaterializationUnit.
//  */
// void LLVMOrcDisposeMaterializationUnit(LLVMOrcMaterializationUnitRef MU);
//
// /**
//  * Create a custom MaterializationUnit.
//  *
//  * Name is a name for this MaterializationUnit to be used for identification
//  * and logging purposes (e.g. if this MaterializationUnit produces an
//  * object buffer then the name of that buffer will be derived from this name).
//  *
//  * The Syms list contains the names and linkages of the symbols provided by this
//  * unit. This function takes ownership of the elements of the Syms array. The
//  * Name fields of the array elements are taken to have been retained for this
//  * function. The client should *not* release the elements of the array, but is
//  * still responsible for destroying the array itself.
//  *
//  * The InitSym argument indicates whether or not this MaterializationUnit
//  * contains static initializers. If three are no static initializers (the common
//  * case) then this argument should be null. If there are static initializers
//  * then InitSym should be set to a unique name that also appears in the Syms
//  * list with the LLVMJITSymbolGenericFlagsMaterializationSideEffectsOnly flag
//  * set. This function takes ownership of the InitSym, which should have been
//  * retained twice on behalf of this function: once for the Syms entry and once
//  * for InitSym. If clients wish to use the InitSym value after this function
//  * returns they must retain it once more for themselves.
//  *
//  * If any of the symbols in the Syms list is looked up then the Materialize
//  * function will be called.
//  *
//  * If any of the symbols in the Syms list is overridden then the Discard
//  * function will be called.
//  *
//  * The caller owns the underling MaterializationUnit and is responsible for
//  * either passing it to a JITDylib (via LLVMOrcJITDylibDefine) or disposing
//  * of it by calling LLVMOrcDisposeMaterializationUnit.
//  */
// LLVMOrcMaterializationUnitRef LLVMOrcCreateCustomMaterializationUnit(
//     const char *Name, void *Ctx, LLVMOrcCSymbolFlagsMapPairs Syms,
//     size_t NumSyms, LLVMOrcSymbolStringPoolEntryRef InitSym,
//     LLVMOrcMaterializationUnitMaterializeFunction Materialize,
//     LLVMOrcMaterializationUnitDiscardFunction Discard,
//     LLVMOrcMaterializationUnitDestroyFunction Destroy);
//
// /**
//  * Create a MaterializationUnit to define the given symbols as pointing to
//  * the corresponding raw addresses.
//  *
//  * This function takes ownership of the elements of the Syms array. The Name
//  * fields of the array elements are taken to have been retained for this
//  * function. This allows the following pattern...
//  *
//  *   size_t NumPairs;
//  *   LLVMOrcCSymbolMapPairs Sym;
//  *   -- Build Syms array --
//  *   LLVMOrcMaterializationUnitRef MU =
//  *       LLVMOrcAbsoluteSymbols(Syms, NumPairs);
//  *
//  * ... without requiring cleanup of the elements of the Sym array afterwards.
//  *
//  * The client is still responsible for deleting the Sym array itself.
//  *
//  * If a client wishes to reuse elements of the Sym array after this call they
//  * must explicitly retain each of the elements for themselves.
//  */
// LLVMOrcMaterializationUnitRef
// LLVMOrcAbsoluteSymbols(LLVMOrcCSymbolMapPairs Syms, size_t NumPairs);
//
// /**
//  * Create a MaterializationUnit to define lazy re-expots. These are callable
//  * entry points that call through to the given symbols.
//  *
//  * This function takes ownership of the CallableAliases array. The Name
//  * fields of the array elements are taken to have been retained for this
//  * function. This allows the following pattern...
//  *
//  *   size_t NumPairs;
//  *   LLVMOrcCSymbolAliasMapPairs CallableAliases;
//  *   -- Build CallableAliases array --
//  *   LLVMOrcMaterializationUnitRef MU =
//  *      LLVMOrcLazyReexports(LCTM, ISM, JD, CallableAliases, NumPairs);
//  *
//  * ... without requiring cleanup of the elements of the CallableAliases array afterwards.
//  *
//  * The client is still responsible for deleting the CallableAliases array itself.
//  *
//  * If a client wishes to reuse elements of the CallableAliases array after this call they
//  * must explicitly retain each of the elements for themselves.
//  */
// LLVMOrcMaterializationUnitRef LLVMOrcLazyReexports(
//     LLVMOrcLazyCallThroughManagerRef LCTM, LLVMOrcIndirectStubsManagerRef ISM,
//     LLVMOrcJITDylibRef SourceRef, LLVMOrcCSymbolAliasMapPairs CallableAliases,
//     size_t NumPairs);
// // TODO: ImplSymbolMad SrcJDLoc
//
// /**
//  * Disposes of the passed MaterializationResponsibility object.
//  *
//  * This should only be done after the symbols covered by the object have either
//  * been resolved and emitted (via
//  * LLVMOrcMaterializationResponsibilityNotifyResolved and
//  * LLVMOrcMaterializationResponsibilityNotifyEmitted) or failed (via
//  * LLVMOrcMaterializationResponsibilityFailMaterialization).
//  */
// void LLVMOrcDisposeMaterializationResponsibility(
//     LLVMOrcMaterializationResponsibilityRef MR);
//
// /**
//  * Returns the target JITDylib that these symbols are being materialized into.
//  */
// LLVMOrcJITDylibRef LLVMOrcMaterializationResponsibilityGetTargetDylib(
//     LLVMOrcMaterializationResponsibilityRef MR);
//
// /**
//  * Returns the ExecutionSession for this MaterializationResponsibility.
//  */
// LLVMOrcExecutionSessionRef
// LLVMOrcMaterializationResponsibilityGetExecutionSession(
//     LLVMOrcMaterializationResponsibilityRef MR);
//
// /**
//  * Returns the symbol flags map for this responsibility instance.
//  *
//  * The length of the array is returned in NumPairs and the caller is responsible
//  * for the returned memory and needs to call LLVMOrcDisposeCSymbolFlagsMap.
//  *
//  * To use the returned symbols beyond the lifetime of the
//  * MaterializationResponsibility requires the caller to retain the symbols
//  * explicitly.
//  */
// LLVMOrcCSymbolFlagsMapPairs LLVMOrcMaterializationResponsibilityGetSymbols(
//     LLVMOrcMaterializationResponsibilityRef MR, size_t *NumPairs);
//
// /**
//  * Disposes of the passed LLVMOrcCSymbolFlagsMap.
//  *
//  * Does not release the entries themselves.
//  */
// void LLVMOrcDisposeCSymbolFlagsMap(LLVMOrcCSymbolFlagsMapPairs Pairs);
//
// /**
//  * Returns the initialization pseudo-symbol, if any. This symbol will also
//  * be present in the SymbolFlagsMap for this MaterializationResponsibility
//  * object.
//  *
//  * The returned symbol is not retained over any mutating operation of the
//  * Materialization Responsibility or beyond the lifetime thereof.
//  */
// LLVMOrcSymbolStringPoolEntryRef
// LLVMOrcMaterializationResponsibilityGetInitializerSymbol(
//     LLVMOrcMaterializationResponsibilityRef MR);
//
// /**
//  * Returns the names of any symbols covered by this
//  * MaterializationResponsibility object that have queries pending. This
//  * information can be used to return responsibility for unrequested symbols
//  * back to the JITDylib via the delegate method.
//  */
// LLVMOrcSymbolStringPoolEntryRef *
// LLVMOrcMaterializationResponsibilityGetRequestedSymbols(
//     LLVMOrcMaterializationResponsibilityRef MR, size_t *NumSymbols);
//
// /**
//  * Disposes of the passed LLVMOrcSymbolStringPoolEntryRef* .
//  *
//  * Does not release the symbols themselves.
//  */
// void LLVMOrcDisposeSymbols(LLVMOrcSymbolStringPoolEntryRef *Symbols);
//
// /**
//  * Notifies the target JITDylib that the given symbols have been resolved.
//  * This will update the given symbols' addresses in the JITDylib, and notify
//  * any pending queries on the given symbols of their resolution. The given
//  * symbols must be ones covered by this MaterializationResponsibility
//  * instance. Individual calls to this method may resolve a subset of the
//  * symbols, but all symbols must have been resolved prior to calling emit.
//  *
//  * This method will return an error if any symbols being resolved have been
//  * moved to the error state due to the failure of a dependency. If this
//  * method returns an error then clients should log it and call
//  * LLVMOrcMaterializationResponsibilityFailMaterialization. If no dependencies
//  * have been registered for the symbols covered by this
//  * MaterializationResponsibility then this method is guaranteed to return
//  * LLVMErrorSuccess.
//  */
// LLVMErrorRef LLVMOrcMaterializationResponsibilityNotifyResolved(
//     LLVMOrcMaterializationResponsibilityRef MR, LLVMOrcCSymbolMapPairs Symbols,
//     size_t NumPairs);
//
// /**
//  * Notifies the target JITDylib (and any pending queries on that JITDylib)
//  * that all symbols covered by this MaterializationResponsibility instance
//  * have been emitted.
//  *
//  * This function takes ownership of the symbols in the Dependencies struct.
//  * This allows the following pattern...
//  *
//  *   LLVMOrcSymbolStringPoolEntryRef Names[] = {...};
//  *   LLVMOrcCDependenceMapPair Dependence = {JD, {Names, sizeof(Names)}}
//  *   LLVMOrcMaterializationResponsibilityAddDependencies(JD, Name, &Dependence,
//  * 1);
//  *
//  * ... without requiring cleanup of the elements of the Names array afterwards.
//  *
//  * The client is still responsible for deleting the Dependencies.Names arrays,
//  * and the Dependencies array itself.
//  *
//  * This method will return an error if any symbols being resolved have been
//  * moved to the error state due to the failure of a dependency. If this
//  * method returns an error then clients should log it and call
//  * LLVMOrcMaterializationResponsibilityFailMaterialization.
//  * If no dependencies have been registered for the symbols covered by this
//  * MaterializationResponsibility then this method is guaranteed to return
//  * LLVMErrorSuccess.
//  */
// LLVMErrorRef LLVMOrcMaterializationResponsibilityNotifyEmitted(
//     LLVMOrcMaterializationResponsibilityRef MR,
//     LLVMOrcCSymbolDependenceGroup *SymbolDepGroups, size_t NumSymbolDepGroups);
//
// /**
//  * Attempt to claim responsibility for new definitions. This method can be
//  * used to claim responsibility for symbols that are added to a
//  * materialization unit during the compilation process (e.g. literal pool
//  * symbols). Symbol linkage rules are the same as for symbols that are
//  * defined up front: duplicate strong definitions will result in errors.
//  * Duplicate weak definitions will be discarded (in which case they will
//  * not be added to this responsibility instance).
//  *
//  * This method can be used by materialization units that want to add
//  * additional symbols at materialization time (e.g. stubs, compile
//  * callbacks, metadata)
//  */
// LLVMErrorRef LLVMOrcMaterializationResponsibilityDefineMaterializing(
//     LLVMOrcMaterializationResponsibilityRef MR,
//     LLVMOrcCSymbolFlagsMapPairs Pairs, size_t NumPairs);
//
// /**
//  * Notify all not-yet-emitted covered by this MaterializationResponsibility
//  * instance that an error has occurred.
//  * This will remove all symbols covered by this MaterializationResponsibility
//  * from the target JITDylib, and send an error to any queries waiting on
//  * these symbols.
//  */
// void LLVMOrcMaterializationResponsibilityFailMaterialization(
//     LLVMOrcMaterializationResponsibilityRef MR);
//
// /**
//  * Transfers responsibility to the given MaterializationUnit for all
//  * symbols defined by that MaterializationUnit. This allows
//  * materializers to break up work based on run-time information (e.g.
//  * by introspecting which symbols have actually been looked up and
//  * materializing only those).
//  */
// LLVMErrorRef LLVMOrcMaterializationResponsibilityReplace(
//     LLVMOrcMaterializationResponsibilityRef MR,
//     LLVMOrcMaterializationUnitRef MU);
//
// /**
//  * Delegates responsibility for the given symbols to the returned
//  * materialization responsibility. Useful for breaking up work between
//  * threads, or different kinds of materialization processes.
//  *
//  * The caller retains responsibility of the the passed
//  * MaterializationResponsibility.
//  */
// LLVMErrorRef LLVMOrcMaterializationResponsibilityDelegate(
//     LLVMOrcMaterializationResponsibilityRef MR,
//     LLVMOrcSymbolStringPoolEntryRef *Symbols, size_t NumSymbols,
//     LLVMOrcMaterializationResponsibilityRef *Result);
//
// /**
//  * Create a "bare" JITDylib.
//  *
//  * The client is responsible for ensuring that the JITDylib's name is unique,
//  * e.g. by calling LLVMOrcExecutionSessionGetJTIDylibByName first.
//  *
//  * This call does not install any library code or symbols into the newly
//  * created JITDylib. The client is responsible for all configuration.
//  */
// LLVMOrcJITDylibRef
// LLVMOrcExecutionSessionCreateBareJITDylib(LLVMOrcExecutionSessionRef ES,
//                                           const char *Name);
//
// /**
//  * Create a JITDylib.
//  *
//  * The client is responsible for ensuring that the JITDylib's name is unique,
//  * e.g. by calling LLVMOrcExecutionSessionGetJTIDylibByName first.
//  *
//  * If a Platform is attached to the ExecutionSession then
//  * Platform::setupJITDylib will be called to install standard platform symbols
//  * (e.g. standard library interposes). If no Platform is installed then this
//  * call is equivalent to LLVMExecutionSessionRefCreateBareJITDylib and will
//  * always return success.
//  */
// LLVMErrorRef
// LLVMOrcExecutionSessionCreateJITDylib(LLVMOrcExecutionSessionRef ES,
//                                       LLVMOrcJITDylibRef *Result,
//                                       const char *Name);
//
// /**
//  * Returns the JITDylib with the given name, or NULL if no such JITDylib
//  * exists.
//  */
// LLVMOrcJITDylibRef
// LLVMOrcExecutionSessionGetJITDylibByName(LLVMOrcExecutionSessionRef ES,
//                                          const char *Name);
//
// /**
//  * Return a reference to a newly created resource tracker associated with JD.
//  * The tracker is returned with an initial ref-count of 1, and must be released
//  * with LLVMOrcReleaseResourceTracker when no longer needed.
//  */
// LLVMOrcResourceTrackerRef
// LLVMOrcJITDylibCreateResourceTracker(LLVMOrcJITDylibRef JD);
//
// /**
//  * Return a reference to the default resource tracker for the given JITDylib.
//  * This operation will increase the retain count of the tracker: Clients should
//  * call LLVMOrcReleaseResourceTracker when the result is no longer needed.
//  */
// LLVMOrcResourceTrackerRef
// LLVMOrcJITDylibGetDefaultResourceTracker(LLVMOrcJITDylibRef JD);
//
// /**
//  * Add the given MaterializationUnit to the given JITDylib.
//  *
//  * If this operation succeeds then JITDylib JD will take ownership of MU.
//  * If the operation fails then ownership remains with the caller who should
//  * call LLVMOrcDisposeMaterializationUnit to destroy it.
//  */
// LLVMErrorRef LLVMOrcJITDylibDefine(LLVMOrcJITDylibRef JD,
//                                    LLVMOrcMaterializationUnitRef MU);
//
// /**
//  * Calls remove on all trackers associated with this JITDylib, see
//  * JITDylib::clear().
//  */
// LLVMErrorRef LLVMOrcJITDylibClear(LLVMOrcJITDylibRef JD);
//
// /**
//  * Add a DefinitionGenerator to the given JITDylib.
//  *
//  * The JITDylib will take ownership of the given generator: The client is no
//  * longer responsible for managing its memory.
//  */
// void LLVMOrcJITDylibAddGenerator(LLVMOrcJITDylibRef JD,
//                                  LLVMOrcDefinitionGeneratorRef DG);
//
// /**
//  * Create a custom generator.
//  *
//  * The F argument will be used to implement the DefinitionGenerator's
//  * tryToGenerate method (see
//  * LLVMOrcCAPIDefinitionGeneratorTryToGenerateFunction).
//  *
//  * Ctx is a context object that will be passed to F. This argument is
//  * permitted to be null.
//  *
//  * Dispose is the disposal function for Ctx. This argument is permitted to be
//  * null (in which case the client is responsible for the lifetime of Ctx).
//  */
// LLVMOrcDefinitionGeneratorRef LLVMOrcCreateCustomCAPIDefinitionGenerator(
//     LLVMOrcCAPIDefinitionGeneratorTryToGenerateFunction F, void *Ctx,
//     LLVMOrcDisposeCAPIDefinitionGeneratorFunction Dispose);
//
// /**
//  * Continue a lookup that was suspended in a generator (see
//  * LLVMOrcCAPIDefinitionGeneratorTryToGenerateFunction).
//  */
// void LLVMOrcLookupStateContinueLookup(LLVMOrcLookupStateRef S,
//                                       LLVMErrorRef Err);
//
// /**
//  * Get a DynamicLibrarySearchGenerator that will reflect process symbols into
//  * the JITDylib. On success the resulting generator is owned by the client.
//  * Ownership is typically transferred by adding the instance to a JITDylib
//  * using LLVMOrcJITDylibAddGenerator,
//  *
//  * The GlobalPrefix argument specifies the character that appears on the front
//  * of linker-mangled symbols for the target platform (e.g. '_' on MachO).
//  * If non-null, this character will be stripped from the start of all symbol
//  * strings before passing the remaining substring to dlsym.
//  *
//  * The optional Filter and Ctx arguments can be used to supply a symbol name
//  * filter: Only symbols for which the filter returns true will be visible to
//  * JIT'd code. If the Filter argument is null then all process symbols will
//  * be visible to JIT'd code. Note that the symbol name passed to the Filter
//  * function is the full mangled symbol: The client is responsible for stripping
//  * the global prefix if present.
//  */
// LLVMErrorRef LLVMOrcCreateDynamicLibrarySearchGeneratorForProcess(
//     LLVMOrcDefinitionGeneratorRef *Result, char GlobalPrefx,
//     LLVMOrcSymbolPredicate Filter, void *FilterCtx);
//
// /**
//  * Get a LLVMOrcCreateDynamicLibrarySearchGeneratorForPath that will reflect
//  * library symbols into the JITDylib. On success the resulting generator is
//  * owned by the client. Ownership is typically transferred by adding the
//  * instance to a JITDylib using LLVMOrcJITDylibAddGenerator,
//  *
//  * The GlobalPrefix argument specifies the character that appears on the front
//  * of linker-mangled symbols for the target platform (e.g. '_' on MachO).
//  * If non-null, this character will be stripped from the start of all symbol
//  * strings before passing the remaining substring to dlsym.
//  *
//  * The optional Filter and Ctx arguments can be used to supply a symbol name
//  * filter: Only symbols for which the filter returns true will be visible to
//  * JIT'd code. If the Filter argument is null then all library symbols will
//  * be visible to JIT'd code. Note that the symbol name passed to the Filter
//  * function is the full mangled symbol: The client is responsible for stripping
//  * the global prefix if present.
//  * 
//  * THIS API IS EXPERIMENTAL AND LIKELY TO CHANGE IN THE NEAR FUTURE!
//  * 
//  */
// LLVMErrorRef LLVMOrcCreateDynamicLibrarySearchGeneratorForPath(
//     LLVMOrcDefinitionGeneratorRef *Result, const char *FileName,
//     char GlobalPrefix, LLVMOrcSymbolPredicate Filter, void *FilterCtx);
//
// /**
//  * Get a LLVMOrcCreateStaticLibrarySearchGeneratorForPath that will reflect
//  * static library symbols into the JITDylib. On success the resulting
//  * generator is owned by the client. Ownership is typically transferred by
//  * adding the instance to a JITDylib using LLVMOrcJITDylibAddGenerator,
//  *
//  * Call with the optional TargetTriple argument will succeed if the file at
//  * the given path is a static library or a MachO universal binary containing a
//  * static library that is compatible with the given triple. Otherwise it will
//  * return an error.
//  *
//  * THIS API IS EXPERIMENTAL AND LIKELY TO CHANGE IN THE NEAR FUTURE!
//  * 
//  */
// LLVMErrorRef LLVMOrcCreateStaticLibrarySearchGeneratorForPath(
//     LLVMOrcDefinitionGeneratorRef *Result, LLVMOrcObjectLayerRef ObjLayer,
//     const char *FileName, const char *TargetTriple);
//
// /**
//  * Create a ThreadSafeContext containing a new LLVMContext.
//  *
//  * Ownership of the underlying ThreadSafeContext data is shared: Clients
//  * can and should dispose of their ThreadSafeContext as soon as they no longer
//  * need to refer to it directly. Other references (e.g. from ThreadSafeModules)
//  * will keep the data alive as long as it is needed.
//  */
// LLVMOrcThreadSafeContextRef LLVMOrcCreateNewThreadSafeContext(void);

///|
pub extern "C" fn llvm_orc_create_new_thread_safe_context() -> LLVMOrcThreadSafeContextRef = "LLVMOrcCreateNewThreadSafeContext"

//
// /**
//  * Get a reference to the wrapped LLVMContext.
//  */
// LLVMContextRef
// LLVMOrcThreadSafeContextGetContext(LLVMOrcThreadSafeContextRef TSCtx);
//
// /**
//  * Dispose of a ThreadSafeContext.
//  */
// void LLVMOrcDisposeThreadSafeContext(LLVMOrcThreadSafeContextRef TSCtx);

///|
pub extern "C" fn llvm_orc_dispose_thread_safe_context(
  ts_ctx : LLVMOrcThreadSafeContextRef,
) = "LLMVOrcDisposeThreadSafeContext"

//
// /**
//  * Create a ThreadSafeModule wrapper around the given LLVM module. This takes
//  * ownership of the M argument which should not be disposed of or referenced
//  * after this function returns.
//  *
//  * Ownership of the ThreadSafeModule is unique: If it is transferred to the JIT
//  * (e.g. by LLVMOrcLLJITAddLLVMIRModule) then the client is no longer
//  * responsible for it. If it is not transferred to the JIT then the client
//  * should call LLVMOrcDisposeThreadSafeModule to dispose of it.
//  */
// LLVMOrcThreadSafeModuleRef
// LLVMOrcCreateNewThreadSafeModule(LLVMModuleRef M,
//                                  LLVMOrcThreadSafeContextRef TSCtx);
//

///|
pub extern "C" fn llvm_orc_create_new_thread_safe_module(
  m : LLVMModuleRef,
  ts_ctx : LLVMOrcThreadSafeContextRef,
) -> LLVMOrcThreadSafeModuleRef = "LLVMOrcCreateNewThreadSafeModule"

// /**
//  * Dispose of a ThreadSafeModule. This should only be called if ownership has
//  * not been passed to LLJIT (e.g. because some error prevented the client from
//  * adding this to the JIT).
//  */
// void LLVMOrcDisposeThreadSafeModule(LLVMOrcThreadSafeModuleRef TSM);
//
// /**
//  * Apply the given function to the module contained in this ThreadSafeModule.
//  */
// LLVMErrorRef
// LLVMOrcThreadSafeModuleWithModuleDo(LLVMOrcThreadSafeModuleRef TSM,
//                                     LLVMOrcGenericIRModuleOperationFunction F,
//                                     void *Ctx);
//
// /**
//  * Create a JITTargetMachineBuilder by detecting the host.
//  *
//  * On success the client owns the resulting JITTargetMachineBuilder. It must be
//  * passed to a consuming operation (e.g.
//  * LLVMOrcLLJITBuilderSetJITTargetMachineBuilder) or disposed of by calling
//  * LLVMOrcDisposeJITTargetMachineBuilder.
//  */
// LLVMErrorRef LLVMOrcJITTargetMachineBuilderDetectHost(
//     LLVMOrcJITTargetMachineBuilderRef *Result);
//
// /**
//  * Create a JITTargetMachineBuilder from the given TargetMachine template.
//  *
//  * This operation takes ownership of the given TargetMachine and destroys it
//  * before returning. The resulting JITTargetMachineBuilder is owned by the client
//  * and must be passed to a consuming operation (e.g.
//  * LLVMOrcLLJITBuilderSetJITTargetMachineBuilder) or disposed of by calling
//  * LLVMOrcDisposeJITTargetMachineBuilder.
//  */
// LLVMOrcJITTargetMachineBuilderRef
// LLVMOrcJITTargetMachineBuilderCreateFromTargetMachine(LLVMTargetMachineRef TM);
//
// /**
//  * Dispose of a JITTargetMachineBuilder.
//  */
// void LLVMOrcDisposeJITTargetMachineBuilder(
//     LLVMOrcJITTargetMachineBuilderRef JTMB);
//
// /**
//  * Returns the target triple for the given JITTargetMachineBuilder as a string.
//  *
//  * The caller owns the resulting string as must dispose of it by calling
//  * LLVMDisposeMessage
//  */
// char *LLVMOrcJITTargetMachineBuilderGetTargetTriple(
//     LLVMOrcJITTargetMachineBuilderRef JTMB);
//
// /**
//  * Sets the target triple for the given JITTargetMachineBuilder to the given
//  * string.
//  */
// void LLVMOrcJITTargetMachineBuilderSetTargetTriple(
//     LLVMOrcJITTargetMachineBuilderRef JTMB, const char *TargetTriple);
//
// /**
//  * Add an object to an ObjectLayer to the given JITDylib.
//  *
//  * Adds a buffer representing an object file to the given JITDylib using the
//  * given ObjectLayer instance. This operation transfers ownership of the buffer
//  * to the ObjectLayer instance. The buffer should not be disposed of or
//  * referenced once this function returns.
//  *
//  * Resources associated with the given object will be tracked by the given
//  * JITDylib's default ResourceTracker.
//  */
// LLVMErrorRef LLVMOrcObjectLayerAddObjectFile(LLVMOrcObjectLayerRef ObjLayer,
//                                              LLVMOrcJITDylibRef JD,
//                                              LLVMMemoryBufferRef ObjBuffer);
//
// /**
//  * Add an object to an ObjectLayer using the given ResourceTracker.
//  *
//  * Adds a buffer representing an object file to the given ResourceTracker's
//  * JITDylib using the given ObjectLayer instance. This operation transfers
//  * ownership of the buffer to the ObjectLayer instance. The buffer should not
//  * be disposed of or referenced once this function returns.
//  *
//  * Resources associated with the given object will be tracked by
//  * ResourceTracker RT.
//  */
// LLVMErrorRef
// LLVMOrcObjectLayerAddObjectFileWithRT(LLVMOrcObjectLayerRef ObjLayer,
//                                       LLVMOrcResourceTrackerRef RT,
//                                       LLVMMemoryBufferRef ObjBuffer);
//
// /**
//  * Emit an object buffer to an ObjectLayer.
//  *
//  * Ownership of the responsibility object and object buffer pass to this
//  * function. The client is not responsible for cleanup.
//  */
// void LLVMOrcObjectLayerEmit(LLVMOrcObjectLayerRef ObjLayer,
//                             LLVMOrcMaterializationResponsibilityRef R,
//                             LLVMMemoryBufferRef ObjBuffer);
//
// /**
//  * Dispose of an ObjectLayer.
//  */
// void LLVMOrcDisposeObjectLayer(LLVMOrcObjectLayerRef ObjLayer);
//
// void LLVMOrcIRTransformLayerEmit(LLVMOrcIRTransformLayerRef IRTransformLayer,
//                                  LLVMOrcMaterializationResponsibilityRef MR,
//                                  LLVMOrcThreadSafeModuleRef TSM);
//
// /**
//  * Set the transform function of the provided transform layer, passing through a
//  * pointer to user provided context.
//  */
// void LLVMOrcIRTransformLayerSetTransform(
//     LLVMOrcIRTransformLayerRef IRTransformLayer,
//     LLVMOrcIRTransformLayerTransformFunction TransformFunction, void *Ctx);
//
// /**
//  * Set the transform function on an LLVMOrcObjectTransformLayer.
//  */
// void LLVMOrcObjectTransformLayerSetTransform(
//     LLVMOrcObjectTransformLayerRef ObjTransformLayer,
//     LLVMOrcObjectTransformLayerTransformFunction TransformFunction, void *Ctx);
//
// /**
//  * Create a LocalIndirectStubsManager from the given target triple.
//  *
//  * The resulting IndirectStubsManager is owned by the client
//  * and must be disposed of by calling LLVMOrcDisposeDisposeIndirectStubsManager.
//  */
// LLVMOrcIndirectStubsManagerRef
// LLVMOrcCreateLocalIndirectStubsManager(const char *TargetTriple);
//
// /**
//  * Dispose of an IndirectStubsManager.
//  */
// void LLVMOrcDisposeIndirectStubsManager(LLVMOrcIndirectStubsManagerRef ISM);
//
// LLVMErrorRef LLVMOrcCreateLocalLazyCallThroughManager(
//     const char *TargetTriple, LLVMOrcExecutionSessionRef ES,
//     LLVMOrcJITTargetAddress ErrorHandlerAddr,
//     LLVMOrcLazyCallThroughManagerRef *LCTM);
//
// /**
//  * Dispose of an LazyCallThroughManager.
//  */
// void LLVMOrcDisposeLazyCallThroughManager(
//     LLVMOrcLazyCallThroughManagerRef LCTM);
//
// /**
//  * Create a DumpObjects instance.
//  *
//  * DumpDir specifies the path to write dumped objects to. DumpDir may be empty
//  * in which case files will be dumped to the working directory.
//  *
//  * IdentifierOverride specifies a file name stem to use when dumping objects.
//  * If empty then each MemoryBuffer's identifier will be used (with a .o suffix
//  * added if not already present). If an identifier override is supplied it will
//  * be used instead, along with an incrementing counter (since all buffers will
//  * use the same identifier, the resulting files will be named <ident>.o,
//  * <ident>.2.o, <ident>.3.o, and so on). IdentifierOverride should not contain
//  * an extension, as a .o suffix will be added by DumpObjects.
//  */
// LLVMOrcDumpObjectsRef LLVMOrcCreateDumpObjects(const char *DumpDir,
//                                                const char *IdentifierOverride);
//
// /**
//  * Dispose of a DumpObjects instance.
//  */
// void LLVMOrcDisposeDumpObjects(LLVMOrcDumpObjectsRef DumpObjects);
//
// /**
//  * Dump the contents of the given MemoryBuffer.
//  */
// LLVMErrorRef LLVMOrcDumpObjects_CallOperator(LLVMOrcDumpObjectsRef DumpObjects,
//                                              LLVMMemoryBufferRef *ObjBuffer);
//
// /**
//  * @}
//  */
//
